<html>
<head>
<title> Distributed application debugger </title>
<meta content="">
<style type="text/css" media="screen">@import "../utility/feuille.css";</style>
</head>
<body>
<br>
  
<!--page's title-->
<div id = "title">
	<!--place image-->
	<div id = "leftimage">
		 <img src="../utility/image/titre.jpg" width="100" height="90">
	</div>
	<div id = "texttitle">
		</br>
		The distributed debugger
	</div>
	<!--place image-->
	<div id = "rightimage">
		 <img src="../utility/image/titre.jpg" width="100" height="90">
	</div>
</div>

<br>
<!--project's causes -->
<div id = "border">
	<div id  = "parts">
		<h1>Why a debugger for distributed applications ?</h1>
	</div>
	<ul>
		<li>
			<h2>What's a distributed application ?</h2>
			<h4>
			Distributed programming allows communications between computers on networks. A distributed application is a program divided into several parts which can be executed on different computers at the same time.
			</h4>
		</li>
		<li>
			<h2>A useful tool...</h2>
			<h4>
			Many programs are now distributed. Indeed, there are lots of advantages with distributed applications: divided work, improved performances, improved reliability... </br>
			However, debugging distributed programs is very hard. There are many external factors which have an impact on program execution (network behaviour, CPU load...), that's why each execution is unique.</br>
			An error in the distributed program can be caused by some events that happened on different computers in a specific order. To correct these programs, we have to reproduce the same events in the same order. This requires executing again an application on every computer, with exactly the same message exchanges. At the present time, no software proposes this functionality. Our software, the distributed debugger, is the first tool that allows programmers to debug distributed applications. </br>
			</h4>
		</li>
		<li>
			<h2>The distributed debugger :</h2>
			<h4>
			This debugger will help programmers to find errors in distributed programs.</br> Our software will give all tools needed to debug distributed applications.
			</h4>
		</li>
	</ul>
	<div id  = "parts">
		<h1>Debugger functionalities :</h1>
	</div>
			<h4> 
			To debug distributed applications, we have to reproduce an identical execution of the program. 
			Primarily, we have to collect execution traces. The spy goes in the background during application execution. 
			It doesn't influence the application behaviour; it just collects traces needed for the replay mode. The replay takes place during a new execution. 
			It consists essentially in arranging messages to respect the initial scenario. During the replay, faults are also processed. 
			Losses and duplications are treated to respect thoroughly the initial execution. 
			The user will be able to observe traces of different executions to study the behaviour of his program. 
			</h4>
	<ul>	
		<li>
			<h2>The replay :</h2>
			<h4>
			This feature will allow the user to execute again an execution???. He will be able to observe if his program reacts in the same way during the replay. 
			</h4>
				<ul>	
					<li>
						<h3>
						On all posts :</br>
						</h3>
						<h4>
						This replay allows the user to observe the reactions of all the posts concerned by the distributed application.</br>
						</br>
						
						In real time, this replay goes in one way; it is the closest to the initial scenario. The execution time is quite similar to the initial execution, indeed, it just has to arrange messages and reproduce faults.  </br>
						</br>
						In step by step mode, the user can observe messages one by one. Execution time increases but this mode allows the user to observe exchanges live. 
						</h4>
						
					</li>
					<li>
						<h3>
						On one post : </br>
						</h3>	
						<h4>
						This replay allows the user to observe one post in particular and check that his actions are normal. This functionality is very useful when a computer seems to have a problem and we want to be sure of it. </br>
						</br>
						In real time, this replay is just used to collect traces during a new execution to observe them later.</br>
						</br>
						In step by step mode, it will allow the user to see live exchanges between the selected post and the other posts concerned by the execution. 
						</h4>
					</li>					
				</ul>
		</li>
		<li>
			<h2>Observation :</h2>
			<h4>
			This functionality allows the user to observe traces of different executions. One advantage is that the user doesn't have to stay in front of his computer during the execution. He just has to launch a new execution and let it go on. Traces will be automatically collected and the user will be able to observe it when he wants.
			</h4>
			
			<ul>	
				<li>
				<h3>Verification</h3>
					<h4>
					In this mode, the user will be able to check informations exchanged during an execution or a replay. He will be able to choose posts he wants to observe. </br>
					</h4>
				</li>
				<li>
				<h3>Comparison</h3>	
					<h4>
					When two executions are launched with the debugger ("normal" execution or replay), execution traces are saved by the distributed debugger. The user can confront traces of the two executions to observe differences. Those differences are colored to simplify the observation. As with the verification, the user can select posts he wants to observe.</br>
					</h4>
				</li>
				<li>
					<h3>
					Variables consultation :
					</h3>	
					<h4>
					During the replay, the user will be able to consult his application variables state. </br>
					</h4>
				</li>
					
				</ul>
		</li>
	</ul>
	<div id  = "name">
		<h5>
			Created by lovely boys and girls of debug' project !
			<br>
			Project available at http://www.irisa.fr
		</h5>
	</div>
	<br>
</div>
   
</body>
</html>
